/**
 * 缺陷选项 composable
 * 统一管理缺陷模块的状态、优先级、严重程度、来源、标签选项
 * 从接口获取数据，避免硬编码
 * 使用全局共享状态，避免多个组件重复调用接口
 */
import { ref, computed } from 'vue'
import { getDefectOptions, type DefectOptions } from '@/api/defect'
import { sourceApi } from '@/api/source'
import { ModuleType } from '@/types/core'
import { useDefectStates } from './useDefectStates'

interface DefectOptionItem {
  code: string
  name: string
  color: string
  description?: string
  sort_order?: number
}

interface DefectSeverityItem {
  code: string
  name: string
  color: string
}

interface DefectSourceItem {
  code: string
  name: string
  color?: string
  description?: string
  sort_order?: number
  is_enabled?: boolean
}

interface DefectTagItem {
  id: string
  name: string
  color: string
  description?: string
}

// 不再使用备用硬编码数据，所有选项都从API获取

// 全局共享状态（单例模式）
const globalState = {
  // 选项数据
  priorityOptions: ref<DefectOptionItem[]>([]),
  severityOptions: ref<DefectSeverityItem[]>([]),
  sourceOptions: ref<DefectSourceItem[]>([]),
  tagOptions: ref<DefectTagItem[]>([]),
  loading: ref(false),
  error: ref<string | null>(null),
  
  // 缓存和去重
  loadingPromise: null as Promise<void> | null,
  lastLoadTime: 0,
  cacheDuration: 5 * 60 * 1000, // 5分钟缓存
  
  // 是否已初始化
  initialized: false
}

export function useDefectOptions() {
  const { statusOptions: defectStatusOptions, loadStates: loadDefectStates } = useDefectStates()
  
  // 使用全局共享状态
  const priorityOptions = globalState.priorityOptions
  const severityOptions = globalState.severityOptions
  const sourceOptions = globalState.sourceOptions
  const tagOptions = globalState.tagOptions
  const loading = globalState.loading
  const error = globalState.error

  // 计算属性：状态选项（从 useDefectStates 获取）
  const statusOptions = computed(() => {
    return defectStatusOptions.value.map(s => ({
      code: s.value,
      name: s.label,
      color: s.color || '#909399',
      description: undefined
    }))
  })

  // 计算属性：优先级选项（格式化）
  const formattedPriorityOptions = computed(() => {
    return priorityOptions.value.map(p => ({
      value: p.code,
      label: p.name,
      color: p.color,
      description: p.description
    }))
  })

  // 计算属性：严重程度选项（格式化）
  const formattedSeverityOptions = computed(() => {
    return severityOptions.value.map(s => ({
      value: s.code,
      label: s.name,
      color: s.color
    }))
  })

  // 计算属性：来源选项（格式化）
  const formattedSourceOptions = computed(() => {
    // 不使用备用硬编码数据，只使用从API获取的数据
    return sourceOptions.value
      .filter(s => s && s.code && s.name && (s.is_enabled === undefined || s.is_enabled !== false))
      .map(s => ({
        value: String(s.code || ''),
        label: String(s.name || ''),
        code: s.code,
        color: s.color || '#909399',
        sort_order: s.sort_order || 0
      }))
      .filter(opt => opt.value && opt.label)
      .sort((a: any, b: any) => (a.sort_order || 0) - (b.sort_order || 0))
  })

  // 计算属性：标签选项（格式化）
  const formattedTagOptions = computed(() => {
    return tagOptions.value.map(t => ({
      id: t.id,
      name: t.name,
      color: t.color,
      description: t.description
    }))
  })

  // 根据代码获取优先级名称
  const getPriorityName = (code: string) => {
    const option = priorityOptions.value.find(p => p.code === code)
    return option?.name || code
  }

  // 根据代码获取优先级颜色
  const getPriorityColor = (code: string) => {
    const option = priorityOptions.value.find(p => p.code === code)
    return option?.color || '#909399'
  }

  // 根据代码获取严重程度名称
  const getSeverityName = (code: string) => {
    const option = severityOptions.value.find(s => s.code === code)
    return option?.name || code
  }

  // 根据代码获取严重程度颜色
  const getSeverityColor = (code: string) => {
    const option = severityOptions.value.find(s => s.code === code)
    return option?.color || '#909399'
  }

  // 根据代码获取来源名称
  const getSourceName = (code: string) => {
    const option = sourceOptions.value.find(s => s.code === code)
    if (option) return option.name
    // 不使用备用硬编码数据，直接返回代码
    return code
  }

  // 根据代码获取来源颜色
  const getSourceColor = (code: string) => {
    const option = sourceOptions.value.find(s => s.code === code)
    if (option) return option.color || '#909399'
    // 不使用备用硬编码数据，返回默认颜色
    return '#909399'
  }

  // 根据代码获取优先级类型（用于 Element Plus tag type）
  const getPriorityType = (code: string): 'info' | 'success' | 'warning' | 'danger' | 'primary' => {
    const color = getPriorityColor(code)
    // 将颜色转换为 Element Plus 的 tag type
    const colorMap: Record<string, 'info' | 'success' | 'warning' | 'danger' | 'primary'> = {
      '#67C23A': 'success',
      '#E6A23C': 'warning',
      '#F56C6C': 'danger',
      '#409EFF': 'primary',
      '#909399': 'info',
      '#C0C4CC': 'info'
    }
    // 尝试匹配颜色
    for (const [colorKey, type] of Object.entries(colorMap)) {
      if (color.toLowerCase() === colorKey.toLowerCase()) {
        return type
      }
    }
    // 回退到基于代码的默认映射
    const codeMap: Record<string, 'info' | 'success' | 'warning' | 'danger' | 'primary'> = {
      low: 'info',
      medium: 'warning',
      high: 'warning',
      critical: 'danger',
      urgent: 'danger'
    }
    return codeMap[code.toLowerCase()] || 'info'
  }

  // 根据代码获取严重程度类型（用于 Element Plus tag type）
  const getSeverityType = (code: string): 'info' | 'success' | 'warning' | 'danger' | 'primary' => {
    const color = getSeverityColor(code)
    // 将颜色转换为 Element Plus 的 tag type
    const colorMap: Record<string, 'info' | 'success' | 'warning' | 'danger' | 'primary'> = {
      '#67C23A': 'success',
      '#E6A23C': 'warning',
      '#F56C6C': 'danger',
      '#409EFF': 'primary',
      '#909399': 'info',
      '#C0C4CC': 'info'
    }
    // 尝试匹配颜色
    for (const [colorKey, type] of Object.entries(colorMap)) {
      if (color.toLowerCase() === colorKey.toLowerCase()) {
        return type
      }
    }
    // 回退到基于代码的默认映射
    const codeMap: Record<string, 'info' | 'success' | 'warning' | 'danger' | 'primary'> = {
      trivial: 'info',
      minor: 'info',
      major: 'warning',
      important: 'warning',
      critical: 'danger',
      urgent: 'danger',
      blocker: 'danger'
    }
    return codeMap[code.toLowerCase()] || 'info'
  }

  // 获取默认优先级
  const defaultPriority = computed(() => {
    // 优先返回中等优先级，如果没有则返回第一个
    return priorityOptions.value.find(p => p.code === 'medium') || priorityOptions.value[0]
  })

  // 获取默认严重程度
  const defaultSeverity = computed(() => {
    // 优先返回次要严重程度，如果没有则返回第一个
    return severityOptions.value.find(s => s.code === 'minor') || severityOptions.value[0]
  })

  // 获取默认来源
  const defaultSource = computed(() => {
    // 优先返回测试来源，如果没有则返回第一个，不使用备用硬编码数据
    return sourceOptions.value.find(s => s.code === 'testing') || sourceOptions.value[0] || null
  })

  // 加载所有选项数据（带缓存和去重）
  const loadOptions = async (forceRefresh = false) => {
    // 如果正在加载中，返回现有的 Promise，避免重复请求
    if (globalState.loadingPromise && !forceRefresh) {
      return globalState.loadingPromise
    }
    
    // 检查缓存是否有效
    const now = Date.now()
    const isCacheValid = !forceRefresh && 
                        globalState.initialized && 
                        (now - globalState.lastLoadTime) < globalState.cacheDuration &&
                        priorityOptions.value.length > 0
    
    if (isCacheValid) {
      return Promise.resolve()
    }
    
    // 创建加载 Promise
    const loadPromise = (async () => {
      try {
        loading.value = true
        error.value = null

        // 加载状态数据（使用 useDefectStates）
        await loadDefectStates()

        // 加载其他选项数据
        const response = await getDefectOptions()
        
        if (response.success && response.data) {
          const options = response.data as DefectOptions
          
          // 更新优先级选项
          priorityOptions.value = options.priority || []
          
          // 更新严重程度选项
          severityOptions.value = options.severity || []
          
          // 更新标签选项
          tagOptions.value = options.tags || []
        }
        
        // 加载来源选项（从来源管理API获取）
        try {
          const sourceResponse = await sourceApi.getAll(ModuleType.DEFECT)
          
          if (sourceResponse && sourceResponse.success && sourceResponse.data) {
            const sources = Array.isArray(sourceResponse.data) ? sourceResponse.data : []
            sourceOptions.value = sources
              .filter((s: any) => s && s.code && s.is_enabled !== false)
              .map((s: any) => ({
                code: String(s.code || ''),
                name: String(s.name || ''),
                color: s.color || '#909399',
                description: s.description,
                sort_order: s.sort_order || 0,
                is_enabled: s.is_enabled !== false
              }))
              .filter((s: any) => s.code && s.name)
              .sort((a: any, b: any) => (a.sort_order || 0) - (b.sort_order || 0))
          } else if (Array.isArray(sourceResponse)) {
            // 如果直接返回数组（向后兼容）
            sourceOptions.value = sourceResponse
              .filter((s: any) => s && s.code && s.is_enabled !== false)
              .map((s: any) => ({
                code: String(s.code || ''),
                name: String(s.name || ''),
                color: s.color || '#909399',
                description: s.description,
                sort_order: s.sort_order || 0,
                is_enabled: s.is_enabled !== false
              }))
              .filter((s: any) => s.code && s.name)
              .sort((a: any, b: any) => (a.sort_order || 0) - (b.sort_order || 0))
          }
        } catch (sourceError) {
          console.warn('从 API 获取缺陷来源失败:', sourceError)
          // 不使用备用硬编码数据，保持 sourceOptions.value 为空数组
        }
        
        // 更新缓存信息
        globalState.lastLoadTime = now
        globalState.initialized = true
      } catch (err: any) {
        console.error('加载缺陷选项失败:', err)
        error.value = err.message || '加载缺陷选项失败'
        
        // 不使用备用硬编码数据，如果加载失败，保持选项为空数组
      } finally {
        loading.value = false
        globalState.loadingPromise = null
      }
    })()
    
    // 保存 Promise 以便其他调用可以等待
    globalState.loadingPromise = loadPromise
    
    return loadPromise
  }

  return {
    // 原始数据
    statusOptions,
    priorityOptions,
    severityOptions,
    sourceOptions,
    tagOptions,
    
    // 格式化后的选项（用于下拉框）
    formattedPriorityOptions,
    formattedSeverityOptions,
    formattedSourceOptions,
    formattedTagOptions,
    
    // 状态
    loading,
    error,
    
    // 默认值
    defaultPriority,
    defaultSeverity,
    defaultSource,
    
    // 工具函数
    getPriorityName,
    getPriorityColor,
    getPriorityType,
    getSeverityName,
    getSeverityColor,
    getSeverityType,
    getSourceName,
    getSourceColor,
    
    // 加载方法
    loadOptions
  }
}

